/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package DAO;

import POJO.Gianhang;
import UTIL.HibernateUtil;
import java.util.List;
import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

/**
 *
 * @author nhlvu07db373
 */
public class GianhangDAO extends HibernateDaoSupport {

    private Session session;

    /**
     * Lấy danh sách các sản phẩm bao gồm đã xóa
     * @return List các sản phẩm
     */
    public List dsGianhangAll() {
        List list = null;
        session = HibernateUtil.getSessionFactory().openSession();
        try {
            org.hibernate.Transaction ts = session.beginTransaction();
            Criteria crit = session.createCriteria(Gianhang.class);
            list = crit.list();
            ts.commit();
            session.flush();
        } catch (Exception ex) {
            System.err.println(ex.getMessage().toString());
        } finally {
            session.close();
        }
        return list;
    }

    /**
     * Lấy danh sách các sản phẩm bao gồm đã xóa có phân trang
     * @param firstResult dòng đầu tiên cần lấy
     * @param maxResults số dòng tối đa cần lấy
     * @return List các dòng gian hàng
     * @throws Throwable 
     */
    public List dsGianhangAll(int firstResult, int maxResults) throws Throwable {
        List list = null;
        session = HibernateUtil.getSessionFactory().openSession();
        try {
            org.hibernate.Transaction ts = session.beginTransaction();
            Criteria crit = session.createCriteria(Gianhang.class);
            crit.setFirstResult(firstResult);
            crit.setMaxResults(maxResults);
            list = crit.list();
            ts.commit();
            session.flush();

        } catch (Exception ex) {
            System.err.println(ex.getMessage().toString());
        } finally {
            session.close();
        }
        return list;
    }

    /**
     * Lấy danh sách các sản phẩm
     * @return List các sản phẩm
     */
    public List dsGianhangFi(int tinhTrang) {
        List list = null;
        session = HibernateUtil.getSessionFactory().openSession();
        try {
            org.hibernate.Transaction ts = session.beginTransaction();
            Criteria crit = session.createCriteria(Gianhang.class).add(Restrictions.eq("tinhTrang", tinhTrang));
            list = crit.list();
            ts.commit();
            session.flush();
        } catch (Exception ex) {
            System.err.println(ex.getMessage().toString());
        } finally {
            session.close();
        }
        return list;
    }

    /**
     * Lấy danh sách các sản phẩm có phân trang
     * @param firstResult dòng đầu tiên cần lấy
     * @param maxResults số dòng tối đa cần lấy
     * @return List các dòng gian hàng
     * @throws Throwable 
     */
    public List dsGianhangFi(int tinhTrang,int firstResult, int maxResults) throws Throwable {
        List list = null;
        session = HibernateUtil.getSessionFactory().openSession();
        try {
            org.hibernate.Transaction ts = session.beginTransaction();
            Criteria crit = session.createCriteria(Gianhang.class).add(Restrictions.eq("tinhTrang", tinhTrang));
            crit.setFirstResult(firstResult);
            crit.setMaxResults(maxResults);
            list = crit.list();
            ts.commit();
            session.flush();

        } catch (Exception ex) {
            System.err.println(ex.getMessage().toString());
        } finally {
            session.close();
        }
        return list;

    }

    /**
     * Lấy thông tin gian hàng
     * @param maGh tham số truyền vào là mã gian hàng
     * @return 
     */
    public Gianhang layGianhang(String maGh) {
        Gianhang Gh = null;
        session = HibernateUtil.getSessionFactory().openSession();
        try {
            org.hibernate.Transaction ts = session.beginTransaction();
            Criteria crit = session.createCriteria(Gianhang.class).add(Restrictions.like("maGianHang", maGh));
            List list = crit.list();
            Gh = (Gianhang) list.get(0);
            ts.commit();
            session.flush();
        } catch (Exception ex) {
            System.err.println(ex.getMessage().toString());
        } finally {
            session.close();
        }

        return Gh;
    }

    /**
     * Ghi nhận thay đổi hay thêm mới một gian hàng
     * @param Gh gian hang POJO cần ghi nhận hay thêm mới
     * @return trả ra kết quả là true nếu thêm thành công và ngược lại
     */
    public boolean luuGianhang(Gianhang Gh) {
        boolean kq = false;
        if (Gh.getMaGianHang().equals("")) {
            String maGh = new GetIDDAO().getID("GH", "Gianhang", "maGiangHang");
            Gh.setMaGianHang(maGh);
        }
        session = HibernateUtil.getSessionFactory().openSession();
        try {
            org.hibernate.Transaction ts = session.beginTransaction();
            session.saveOrUpdate(Gh);
            ts.commit();
            session.flush();
            kq = true;
        } catch (Exception ex) {
            if (session.getTransaction().isActive()) {
                session.getTransaction().rollback();
            }
            System.err.println(ex.getMessage().toString());
        } finally {
            session.close();
        }
        return kq;
    }

    /**
     * xóa giang hàng
     * @param Gh gian hang POJO hay mã gian hàng(String) cần xóa
     * @return kết quả là true nếu xóa thành công
     */
    public boolean xoaGianhang(Gianhang Gh) {
        session = HibernateUtil.getSessionFactory().openSession();
        boolean kq = false;
        try {
            org.hibernate.Transaction ts = session.beginTransaction();
            session.delete(Gh);
            ts.commit();
            session.flush();
            kq = true;
        } catch (Exception ex) {
            if (session.getTransaction().isActive()) {
                session.getTransaction().rollback();
            }
            System.err.println(ex.getMessage().toString());
        } finally {
            session.close();
        }
        return kq;
    }

    public boolean xoaGianhang(String maGh) {
        Gianhang Gh = layGianhang(maGh);
        return xoaGianhang(Gh);
    }

    /**
     * Đánh dấu xóa gian hàng
     * @param Gh tham số truyền vào là giang hang POJO hay là mã gian hàng(String)
     * @return 
     */
    public boolean danhdauxoaGianhang(Gianhang Gh) {
        Gh.setTinhTrang(0);
        return luuGianhang(Gh);
    }

    public boolean danhdauxoaGianhang(String maGh) {
        Gianhang Gh = layGianhang(maGh);
        Gh.setTinhTrang(0);
        return luuGianhang(Gh);
    }

    /**
     * Lấy tất cả danh sách gian hàng của khu vực
     * @param maKhuVuc mã khu vực (int)
     * @return 
     */
    public List dsGianhangKvAll(int maKhuVuc) {
        List list = null;
        session = HibernateUtil.getSessionFactory().openSession();
        try {
            org.hibernate.Transaction ts = session.beginTransaction();
            Criteria crit = session.createCriteria(Gianhang.class).add(Restrictions.eq("maKhuVuc", maKhuVuc));
            list = crit.list();
            ts.commit();
            session.flush();
        } catch (Exception ex) {
            System.err.println(ex.getMessage().toString());
        } finally {
            session.close();
        }
        return list;
    }

    /**
     * Lấy danh sách các sản phẩm được bày bán của một khu vực theo tình trạng
     * @param maKhuVuc mã khu vực int
     * @param tinhTrang tình trạng 1 là đang bán 0 là hết bán
     * @return 
     */
    public List dsGianhangKvFi(String maKhuVuc, int tinhTrang) {
        List list = null;
        session = HibernateUtil.getSessionFactory().openSession();
        try {
            org.hibernate.Transaction ts = session.beginTransaction();
            Criteria crit = session.createCriteria(Gianhang.class).add(
                    Restrictions.and(Restrictions.eq("maKhuVuc", maKhuVuc), Restrictions.eq("maKhuVuc", maKhuVuc)));
            list = crit.list();
            ts.commit();
            session.flush();
        } catch (Exception ex) {
            System.err.println(ex.getMessage().toString());
        } finally {
            session.close();
        }
        return list;
    }

    /**
     * Lấy danh sách các sản phẩm được bán theo khu vực dựa vào tình trạng có phân trang
     * @param maKhuVuc mã khu vực String
     * @param tinhTrang tình trạng 0 hết bán 1 là còn bán
     * @param firstResult dòng dữ liệu đầu tiên cần lấy
     * @param maxResults số dòng dữ liệu tối đa cần lấy
     * @return List các sản phẩm thỏa mãn
     */
    public List dsGianhangKvFi(String maKhuVuc, int tinhTrang, int firstResult, int maxResults) {
        List list = null;
        session = HibernateUtil.getSessionFactory().openSession();
        try {
            org.hibernate.Transaction ts = session.beginTransaction();
            Criteria crit = session.createCriteria(Gianhang.class).add(
                    Restrictions.and(Restrictions.eq("maKhuVuc", maKhuVuc), Restrictions.eq("maKhuVuc", maKhuVuc)));
            crit.setFirstResult(firstResult);
            crit.setMaxResults(maxResults);
            list = crit.list();
            ts.commit();
            session.flush();
        } catch (Exception ex) {
            System.err.println(ex.getMessage().toString());
        } finally {
            session.close();
        }
        return list;
    }
}
